error printer: never block on, or read from, a file that is not regular - #42323

This is a fuzzer finding (fuzz ledger entry 33881, not a GitHub issue number). No user reported it. BUN_DISABLE_SOURCE_CODE_PREVIEW=1 avoids the code frame read, not the .map read.

Repro on 1.4.3:

cat > a.mjs <<'EOF'
import { unlinkSync } from "node:fs";
import { spawnSync } from "node:child_process";
unlinkSync(import.meta.path);
spawnSync("mkfifo", [import.meta.path]);
console.log("about to throw");
throw new Error("boom");
EOF
bun a.mjs   # prints "about to throw", then nothing, never exits

Opening and closing the write end from another shell (: > a.mjs) releases it: the report prints and bun exits 1. With this change it prints the error and exits 1 at once:

about to throw
2 | import { unlinkSync } from "node:fs";
3 | import { spawnSync } from "node:child_process";
4 | unlinkSync(import.meta.path);
5 | spawnSync("mkfifo", [import.meta.path]);
6 | throw Error("boom");
              ^
error: boom
      at /tmp/x/a.mjs:6:11

The excerpt is the transpiled text JSC holds (collect_source_lines), the same fallback a deleted file gets today. Node v26 prints the line it holds in memory and exits 1 for the replaced module and for the sourceURL case.

The new tests are in the source map remapping of the printed stack block, next to the deleted-file test. Each child blocks forever on 1.4.3:

• the file of a transpiled module is a FIFO with no writer: Bun.inspect(e) returns and the uncaught error prints, frames remapped to swapped.ts:4, exit code 1;
• the same with a writer that put 16 bytes in the pipe: the 16 bytes are still in the pipe after the child exits (before, the child consumed them and stayed in read);
• node:vm code whose //# sourceURL names a FIFO;
• a package.json that is a symlink to a FIFO, in a directory that only a sourceURL names;
• a string assigned to e.stack whose frame names a FIFO (the route through ZigException.cpp, no code runs under that name);
• main.js.map next to a // @bun file is a FIFO: e.stack and the uncaught print both return, frames unmapped;
• a map whose sources[0] is a FIFO and sourcesContent is [null]: frames remapped to orig.ts.

An afterAll in the block kills any child that is still alive, so a regression cannot leave processes behind. Without it the hung children outlived the bun test run. It is afterAll and not afterEach because the tests are concurrent: afterEach runs while sibling tests are in flight and is not told which test it runs for, and onTestFinished throws in a concurrent test.

The package.json lookup: bun_bundler::options::get_loader_and_virtual_source has one caller, fetch_without_on_load_plugins, and that has one caller, the printer, with PrintSource. The lookup gave a module type that PrintSource does not use. In a directory the resolver had not seen, it read the directory, package.json and tsconfig.json. Removed: the LoaderResult::package_json field, the read_dir_info_package_json slot of VmLoaderCtx, its implementation in jsc_hooks.rs, and Loader::is_js_like, whose one caller was the lookup. One other consumer of the module type was on that path, the Node compile cache note for a module that failed to parse. It now runs for real loads only: a failed re-read by the printer is not a parse failure.

Same-class sites left alone, on purpose:

• The other four callers of read_file_with_allocator (package.json, tsconfig.json, the bundler's parse task, the CSS build) and the other four ParseOptions sites pass NonRegularFile::Read. They read right after the resolver found the path, the resolver skips FIFO directory entries, and the arena reader avoids fstat for files under 16 KB on purpose. An import of a symlink that points at a FIFO still blocks in open, as cat would.
• File::read_from keeps its behavior for its other callers. Read whole files only when they are regular files #39734 (open, has conflicts) changes read_from itself after a review of each caller. open_regular_at here has the name, flags and errnos of that PR's helper, without the size that one also returns (nothing here reads it). The same open, fstat, ISREG sequence is inline in RuntimeTranspilerCache.rs (Verify a transpiler cache entry before any field of it is used #39717), env_loader.rs (dotenv: skip .env entries that are not regular files #40711) and Image.rs. Moving those onto the helper is a follow-up.
• No size cap. A regular file reads in bounded time, and the loader has no cap for the same file.
• On Windows there is no O_NONBLOCK (it would make the handle overlapped). The fstat check still applies there.

Related open PRs:

• error: do not read a frame's source URL from disk unless the loader loaded it #41477 stops the disk read for a frame URL the loader did not load. With it the sourceURL, package.json and e.stack tests pass on their own. A module the loader did load stays trusted there and is still read back, so the replaced-module tests need this change.
• Module loading: remove unsafe from ModuleLoader, AsyncModule and RuntimeTranspilerStore #40383 rewrites ModuleLoader, AsyncModule and RuntimeTranspilerStore. The new ParseOptions field is one line in each of four files it touches.

The two downsides, in detail. Cost: open_regular_at is openat then fstat, and the read and close are as before. Nothing is added when the open fails (no .map file, the common case). The size figures are from the size report of build 122351 against main build 122295: +4.0 KB on bun-linux-x64-android and bun-freebsd-x64, +1.5 KB on bun-windows-aarch64, +0.0 KB on the other nine. The waiting writer: I ran a writer that blocks in open(O_WRONLY) on a FIFO at the module's path, then made the program throw. On main the printer read WRITER-PAYLOAD, printed it as the code frame, and the writer exited 0. On this branch the writer's open returns when the printer opens the FIFO, the printer closes it after the fstat, and the writer exits with status 141 at its first write. In both cases a real reader that comes later gets nothing. A stat before the open would leave that writer blocked and untouched, for one more syscall on every file the printer reads. I did not add it: open then fstat is what the tree already does for the transpiler cache entry and the default .env files, and a reader that opens and leaves is something a FIFO writer has to handle anyway.

Self-reviewed: the first version gated only the code frame read, with an inline copy of the check and a bool parameter. The review showed that the .map, sources[i] and package.json reads still blocked on that build (each exit 124 under timeout), so they are in this PR. The bool became the two-value NonRegularFile enum, and the check moved into the bun_sys helper.

Other checks: 500 rejected reads in one process leave the fd count unchanged (10 before, 10 after). cargo clippy on bun_sys, bun_resolver, bun_sourcemap, bun_bundler. cargo check of those for x86_64-pc-windows-msvc and aarch64-apple-darwin. inspect-error-leak.test.js and error-gc-test.test.js fail only by their time limits on the ASAN debug build (the leak test's RSS assertion passes, #39401 tracks its sizing).